class Solution {
public:
//     void Dijkstra(vector<vector<pair<double,int> > >& graph,vector<double>& dist,vector<bool> visited,int n,int start){
//         dist[start] = 1;
//         for(int i = 0;i < n;i++){
//             int u = -1;
//             double maxRate = 0;
//             for(int j = 0;j < n;j++){
//                 if(!visited[j] && dist[j] > maxRate){
//                     u = j;
//                     maxRate = dist[j];
//                 }
//             }
//             if(u == -1){
//                 return;
//             }
//             visited[u] = true;
//             for(auto& [w,v] : graph[u]){
                
            
//                 if(!visited[v] && dist[u] * w > dist[v]){
//                     dist[v] = dist[u] * w;
//                 }
//             }
//         }
        
//     }
    double maxProbability(int n, vector<vector<int>>& edges, vector<double>& succProb, int start, int end) {
  
        vector<vector<pair<double, int>>> graph(n);
        for (int i = 0; i < edges.size(); i++) {
            auto& e = edges[i];
            graph[e[0]].emplace_back(succProb[i], e[1]);
            graph[e[1]].emplace_back(succProb[i], e[0]);
        }

        
        vector<double> dist(n,0);
        
//         vector<bool> visited(n,false);
        
//         Dijkstra(graph,dist,visited,n,start);
        
        priority_queue<pair<double,int> > que;
        que.push({1,start});
        dist[start] = 1;
        
        while(!que.empty()){
            auto [w,u] = que.top();
            que.pop();
            if(w < dist[u]){
                continue;
            }
            
            for(auto& [nw,v] : graph[u]){
                if(dist[u] * nw > dist[v]){
                    dist[v] = dist[u] * nw;
                    que.push({dist[v],v});
                }
            }
        }
 
        return dist[end];
    }
};
